Technotools

home *** CD-ROM | disk | FTP | other *** search

/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / lang_c / mikecom / async.asm < prev next >

Wrap

Assembly Source File | 1987-06-04 | 29.0 KB | 683 lines

title INTERRUPT DRIVEN ASYNC FOR MSC page 75,132 ; Mike Dumdei, 6 Holly Lane, Texarkana TX 75503 ; Version: 5-13-87 comment |====================================================================== This is the main module for the async routines and provides the basic functions necessary to perform serial I/O -- open/close ports, send/receive, and the interrupt handlers. Async_open makes a call to the MicroSoft C library function '_malloc' and the close function calls '_free' to dynamically allocate memory for the rx/tx ring buffers, therefore you must either use the MSC library when linking or provide your own routines for these functions. ==============================================================================| include casmhdr.h defseg COMM_TEXT include async.h ;define segments, equates, & macros IMPORT_NEAR <__ck_port_arg, __convert_bpds, __set_bpds> ifdef FARCODE IMPORT_FAR <_malloc, _free> else IMPORT_NEAR <_malloc, _free> endif ;import external functions _DATA segment ifdef LITES include lites1.inc ;debug data if using onscreen RX/TX ind endif ;---- Table of pointers to com port data structures public __port_dta_tbl __port_dta_tbl dw ofDG com1_dta ;table used to point SI to appropriate dw ofDG com2_dta ;com port data structure ;---- Com data structures for each port, initialized variables in order are: ; the segment & offset of the int hdlr, the int vctr nmbr assoc with the ; COM port, and the mask to enable the IRQ on the int cntrlr chip com1_dta port_dta <,TXT,ofTXT int_hdlr1,0ch,0efh> com2_dta port_dta <,TXT,ofTXT int_hdlr2,0bh,0f7h> ;---- Interrupt handler vectors and pointer to interrupt loop routine intrpt_tbl dw ofTXT msr_intrpt dw ofTXT tx_intrpt dw ofTXT rx_intrpt dw ofTXT lsr_intrpt intrpt_lp_adr dw ofTXT intrpt_loop _DATA ends begseg COMM_TEXT ;****************************************************************************** ; ASYNC_OPEN -- Opens a comm port for use. Returns R_OK if successful else ; returns error code. ;****************************************************************************** ;------------------------------------------------------------------------------ ; This first section of the routine checks the arguments passed to the call ; for validity and converts them to usable form, initializes the data struc- ; ture for that port, and allocates space for the transmit and receive buffers. ;------------------------------------------------------------------------------ publicproc _async_open push bp mov bp,sp push si push di ;stack frame, save reg variables push es push ds pop es ;save old ES and set ES=DS == DGROUP ;---- Get port address and init if valid && not already in use call __ck_port_arg ;rtrns lots of info -- see proc header pushf ;save return status mov cx,ds ;save user DS mov ax,bios_dta mov ds,ax assume ds:bios_dta mov ax,[bx] ;get base address of req com port from bios_dta mov ds,cx ;back to our DS assume ds:DGROUP popf ;restore status of call to __ck_port_arg ifdef DBUG jnc nxt_test1 jmp noporterr nxt_test1: jz nxt_test2 jmp inuseerr else jc noporterr ;CY = port arg passed to async_open was bad jnz inuseerr ;NZ = port has already been opened endif nxt_test2: or ax,ax je noporterr ;no good if BIOS doesn't have base address mov COM_BASE,ax ;store port base address ;---- Translate baud-parity-databit-stopbit string to comm chip language mov bx,BPDS_ptr ;get pointer to b-p-d-s string call __convert_bpds ;call conversion routine or ax,ax jnz err_exit ;error if rtn code wasn't 0 ;---- Get size of transmit and receive buffers and allocate memory for them mov ax,Tx_len ;get size request for transmit buffer cmp ax,MAXBUFSIZE ja arg_err cmp ax,MINTXBUFSIZ jb arg_err ;make sure within MIN/MAX limits mov TX_SIZE,ax mov TX_FREE,ax ;init port data variables mov ax,Rx_len ;get size request for receive buffer cmp ax,MAXBUFSIZE ja arg_err cmp ax,MINRXBUFSIZ jb arg_err ;make sure within MIN/MAX limits mov RX_SIZE,ax mov RX_FREE,ax ;init port data variables add ax,Tx_len ;AX = total bytes of mem to allocate push ax ;setup for call to C lib's 'malloc' call _malloc ;allocate the space and get a pointer to it add sp,2 ifdef FARDATA mov cx,ax add cx,dx jcxz memory_err ;not enough mem if NULL ptr returned else or ax,ax ;not enough mem if NULL ptr returned jz memory_err mov dx,ds ;segment for data in 'near model' is dgroup endif mov RXTX_SEG,dx ;save segment addrs of rx/tx buffers ;---- Finish initialization of the port data structure mov TX_TOP,ax ;save ptr to start of transmit bufr mov TX_IN,ax mov TX_OUT,ax ;init transmit buffer to empty condition ifdef DBUG call dsp_TXIN call dsp_TXOUT endif add ax,Tx_len ;calc start of receive bufr mov RX_TOP,ax ;save ptr to start of receive bufr mov RX_IN,ax mov RX_OUT,ax ;init receive buffer to empty condition ifdef DBUG call dsp_RXIN call dsp_RXOUT endif add ax,Rx_len mov RX_BTM,ax ;save ptr to last byte of rx bufr + 1 mov STATWRD1,0 ;init STAT1 & STAT2 to zero mov STATWRD2,0ff08h ;MSR_NMSK=no MSR flow cntl, TX_STAT=txbuf empty jmp s init_inthndlr ;---- Error exit routines noporterr: mov ax,R_NOPORT jmp s err_exit inuseerr: mov ax,R_PORTINUSE jmp s err_exit arg_err: mov ax,R_BADARG jmp s err_exit memory_err: mov ax,R_NOMEM err_exit: xor bx,bx mov COM_BASE,bx ;show port not in use jmp s opn_exit ;back to C caller ;---------------------------------------------------------------------------- ; At this point all data to initialize the port has been determined and the ; port data structure has been initialized. The next portion of the routine ; initializes the hardware to the selected parameters and sets up and enables ; the communication interrupt handling routines. ;---------------------------------------------------------------------------- ;---- Initialize the communications interrupt handler init_inthndlr: ;---- Get and save old interrupt vector mov al,VECTOR_NBR mov ah,35h int 21h ;get current interrupt vector mov OLDVCTR_SEG,es mov OLDVCTR_OFST,bx ;save for when port closed ;---- Save old value of IER, LSR, and disable 8250 intrpts via the IER mov dx,COM_BASE inc dx ;xF9)interrupt enable register in al,dx jmp s $+2 mov OLD_IER,al ;save original value of IER xor al,al out dx,al ;disable all types 8250 intrpts temporarily jmp s $+2 inc dx inc dx ;xFB) line control register in al,dx mov OLD_LCR,al ;save original value of line contrl register ;---- Set the new interrupt vector, baud rate, & parity, data, stop bits mov dx,NEWVCTR_OFST mov al,VECTOR_NBR push ds mov ds,NEWVCTR_SEG mov ah,25h int 21h ;set new interrupt vector pop ds call __set_bpds ;set the baud,parity,data,stop bits, DisIntrprt ;---- Clear any pending interrupts mov dx,COM_BASE add dx,5 ;xFD) line status register in al,dx ;clear brk or data error type intrpts jmp s $+2 sub dx,5 ;xF8) rx holding register in al,dx ;read rx register to clr its int status jmp s $+2 inc dx inc dx ;xFA) interrupt id register in al,dx ;clr tx holding register empty interrupt cond jmp s $+2 add dx,4 ;xFE) modem status register in al,dx ;read MSR to clear chng in stat type intrpts mov MSR_VAL,al ;save value of MSR jmp s $+2 ;---- Enable RX, LSR, MSR intrpts, save old 8259 mask, & old 8250 MCR value dec dx dec dx ;xFC) pointing to modem cntrl reg (MCR) in al,dx jmp s $+2 mov OLD_MCR,al ;save orig value of modem control reg ifdef RTSFALSE mov al,00001001b ;modem contrl value if RTS is to init'd low else mov al,00001011b endif out dx,al ;enable 8250 com intrpts, set DTR & RTS high jmp s $+2 sub dx,3 ;xF9) pointing to intrpt enable reg mov al,00001101b out dx,al ;enable MSR, LSR, & RX intrpts jmp s $+2 in al,IMR_8259 jmp s $+2 mov ah,MSK_8259 not ah and ah,al mov OLD_8259_MSK,ah ;save old 8259 mask for this IRQ # and al,MSK_8259 out IMR_8259,al ;enable 8259 IRQx interrupt ;---- Finished with initialization sti ;ready to go xor ax,ax ;return R_OK opn_exit: pop es pop di pop si pop bp ret ;restore regs and exit with r_code _async_open endp ;***************************************************************************** ; ASYNC_CLOSE -- This routine closes an opened communications port. All data ; in tx and rx buffers is lost. Returns R_NOPORT if port nmbr was invalid or ; already not active. Returns R_OK if successful. ;***************************************************************************** publicproc _async_close push bp mov bp,sp push si ;setup stk frame and save register varible call __ck_port_arg ;check the port arg and load pointers jz async_clsexit ;return err of invld arg or port not open inc dx ;xF9) enable interrupt register mov al,OLD_IER cli out dx,al ;restore intrpt enable reg to original cond jmp s $+2 inc dx inc dx ;xFB) line control register (LCR) mov al,OLD_LCR out dx,al ;restore LCR to orig value jmp s $+2 inc dx ;xFC) modem control register mov al,OLD_MCR out dx,al ;restore org status of MCR jmp s $+2 in al,IMR_8259 jmp s $+2 or al,OLD_8259_MSK out IMR_8259,al ;restore IRQx to original condition push ds mov al,VECTOR_NBR mov dx,OLDVCTR_OFST mov ds,OLDVCTR_SEG mov ah,25h int 21h ;restore old interrupt vector sti pop ds mov dx,RXTX_SEG ;seg value of ptr mov ax,TX_TOP ;offset of ptr returned by call to 'malloc' push dx push ax ;push both to take care of either mem model call _free add sp,4 ;free mem alloc for RX/TX buffers xor ax,ax ;return R_OK mov COM_BASE,ax ;show port inactive async_clsexit: pop si pop bp ret ;clean up and exit to C _async_close endp ;***************************************************************************** ; ASYNC_TX -- Gets character passed by C caller and puts it in the transmit ; buffer. Returns R_TXERR if no room in bufr or port argument was invalid. ; Returns number bytes left in buffer if tx was successful. ;***************************************************************************** publicproc _async_tx push bp mov bp,sp push si push es ;setup stack and save regs call __ck_port_arg ;ck port argument & load pointers mov ax,R_TXERR jz async_texit ;bad port if ZR cmp TX_FREE,0 je async_texit ;no good if no place to put input char mov es,RXTX_SEG ;get seg of rx/tx bufrs cli mov bx,TX_IN ;get ptr to tx bufr input mov al,TxChar ;get char passed by function call mov es:[bx],al ;put it in the tx bufr inc bx cmp bx,TX_BTM ;ck if time to loop buffer je lp_txptr store_txin: mov TX_IN,bx ;store new 'tx chars in' pointer ifdef DBUG call dsp_TXIN endif dec TX_FREE ;one less byte available in bufr and TX_STAT,n B_TXEMPTY ;clr the nothing to txmt bit in TX_STAT jz start_tx ;start txmtr if not on & no flow cntrl actv get_txfree: mov ax,TX_FREE ;get number bytes left in bufr async_texit: sti pop es pop si pop bp ret ;back to C caller ;---- Following moved here so no jmps taken for most common case (faster) lp_txptr: mov bx,TX_TOP ;reset ptr to top of ring buffer jmp s store_txin ;back to main flow start_tx: call __tx_inton ;start transmitter jmp s get_txfree ;back to main flow _async_tx endp ;****************************************************************************** ; ASYNC_RX -- Receive character routine (read a char from rx buffer). Returns ; STAT1 as high byte. Returns '\0' as char read if buffer was empty and sets ; bit 6 of the STAT1 byte high. Bits 0-4 of STAT1 only indicate an error has ; occurred - not that it occurred on the char just read. Also bits 0-4 error ; conditions stay set until async_reset is called. ; STAT1: 0=rx bufr ovrfl 1=char overrun 2=parity err 3=framing err ; 4=break intrpt 5=invalid port 6=rx bufr empty 7=no carrier ;****************************************************************************** publicproc _async_rx push bp mov bp,sp push si push es ;C stack frame, save regs call __ck_port_arg ;ck Port argument and setup pointers mov ax,0010000000000000b ;set invalid port bit just in case jz async_rexit cli mov ax,RX_FREE sub ax,RX_SIZE je rxbuf_empty ;jump if nothing in rx buffer mov bx,RX_OUT ;ptr to next char to come out of rx bufr mov es,RXTX_SEG ;get seg of rx buffer xor cx,cx mov cl,es:[bx] inc bx ;get a char & incrmnt pointer cmp bx,RX_BTM ;time to close loop on rx bufr? je lp_rxptr ;loop rx pointer if at bottom store_rxptr: mov RX_OUT,bx ;store ptr to next char to get ifdef DBUG call dsp_RXOUT endif inc RX_FREE ;another byte available in rx bufr test STAT2,B_XSENT ;has an XOFF been sent? (NZ = yes) jnz ckxflow_ctl ;see if now time to send XON if XOFF was sent setstat: xor ah,ah ;not rxempty, not invalid port setstat2: or ah,STAT1 ;get STAT bits set by RX/MSR intrpt routines mov al,cl ;AL = char read async_rexit: sti pop es pop si pop bp ret ;back to C caller ;---- Following moved here so no jmps taken for most common case (faster) rxbuf_empty: mov cl,al ;else set char retrned = '\0', mov ah,B_RXEMPTY ;set bit showing bufr empty (AH == 40h), jmp s setstat2 ;and go get rest of status information lp_rxptr: mov bx,RX_TOP ;loop back to top of bufr if it is jmp s store_rxptr ;back to main flow ckxflow_ctl: cmp RX_FREE,XONCOUNT jna setstat ;jmp if rxbuf to full to send XON yet and STAT2,n B_XSENT ;clr bit that indicates XOFF sent active mov TXIMMEDCHAR,XONCHAR ;XON will be next char tx'd and TX_STAT,n B_TXEMPTY ;set bit saying something needs tx'd jnz setstat ;done if tx alrdy on or other flw halt is actv push cx ;save char gotten from rx buffer call __tx_inton ;start the transmitter pop cx jmp s setstat ;restore char and back to main flow _async_rx endp ;**************************************************************************** ; INTERRUPT ROUTINES: ; This is the interrupt handling routine. It is called whenever the receive ; holding register for an active port has a character or when transmitting ; whenever the transmit hold register for a transmitting port is ready for ; another character. Also monitors MSR and LSR interrupts. ;**************************************************************************** ;---- Entry point for interrupt (BX set to slct appropriate port_dta struc) int_hdlr2 proc far push bx ;entry if COM2 interrupted mov bx,ofDG __port_dta_tbl+2 ;BX = ptr to ptr to com2_dta jmp s setup_proc int_hdlr1 proc far push bx ;entry if COM1 interrupted mov bx,ofDG __port_dta_tbl ;BX = ptr to ptr to com1_dta ;---- Allow other intrpts, save regs, and init ptrs to DGROUP, port_dta struc, ; and rx/tx buffers setup_proc: sti push ax push cx push dx push si push ds push es ;save registers mov ax,DGROUP mov ds,ax ;point to our data area mov si,[bx] ;SI = ptr to appropriate port_dta for this prt mov es,RXTX_SEG ;get segment where rx/tx bufrs are located ;---- Main interrupt handling loop. The loop gets the value in the UART ; intrpt ID register and checks the 'intrpt pending bit'. If the bit ; indicates a condition needs servicing the address of the top of the loop ; is pushed onto the stack and then a jump is made to the appropriate serv- ; ice routine. When the final 'ret' is encountered in the service routine, ; control passes back to the top of this loop. intrpt_loop: mov dx,COM_BASE ;DX = COM_BASE (base port address) inc dx inc dx ;xFA) -- Interrupt ident reg in al,dx shr al,1 ;slide 'pendng bit' into CY & ID bits to 1 & 0 jc exit_intrpt ;done if pending bit indic all intrps processed dec dx dec dx ;xF8) - back to base register push DG:intrpt_lp_adr ;this will be return addrs (top of this loop) and ax,0000000000000011b ;make sure only int status infor is in AX shl ax,1 mov bx,ax jmp DG:intrpt_tbl[bx] ;jmp to the appropriate service routine ;---- Exit interrupt routine exit_intrpt: cli mov al,20h out ICR_8259,al ;send 'end of interrupt' to 8259 pop es pop ds pop si pop dx pop cx pop ax pop bx ;restore registers iret ;exit interrupt int_hdlr1 endp int_hdlr2 endp ;---- Interrupt service routine line status register interrupt. localproc lsr_intrpt add dx,5 ;xFD) line status register in al,dx ;reading LSR clears interrupt cond and al,00011110b ;mask off desired bits or STAT1,al ;put them in STAT1 ret ;back to interrupt loop lsr_intrpt endp ;---- Interrupt service routine for modem status register change. Used to ; keep CD bit in STAT1 updated and as part of CTS, DSR, & CD flow ; procedures. localproc msr_intrpt add dx,6 ;xFE) modem status register in al,dx ;reading MSR clears interrupt cond mov MSR_VAL,al ;store MSR mov ah,al ;save MSR reg in AH also mov bl,n B_CD and STAT1,bl ;clr NOT CD bit (!CD) in STAT1 byte not bl and ah,bl ;mask MSR val to isolate CD bit xor ah,bl ;invert CD to make it !CD or STAT1,ah ;update !CD in STAT1 byte mov bx,STATWRD2 ;BH=MSR monitor mask, BL=TX_STAT byte and bl,bh ;clr monitored bits in TX_STAT not bh and al,bh ;mask out un-monitored bits in MSR value xor al,bh ;change monitored bits to their NOT function or al,bl ;combine updtd monitr bits with TX_STAT mov TX_STAT,al ;save new TX_STAT jnz msr_exit ;NZ == tx int running, noth to tx, or flow halt jmp __tx_inton ;if none of abv is true, time to strt tx bak up msr_exit: ret ;back to intrpt loop msr_intrpt endp ;---- Interrupt service routine for a 'char received' interrupt. Received char ; is placed in RX bufr unless it is full. If the bufr is full, char is ; ignored and rx bufr ovrflw bit is set in STAT1. Also performs XON/XOFF ; protocol functions and high bit stripping when using those options. localproc rx_intrpt in al,dx ;get char from 8250 hold reg ifdef LITES call rxlites ;dsplay debug rx lite if using endif and al,STRIP_MASK ;do bit stripping according to strip mask val test STAT2,B_XUSE ;using XON/XOFF protocol? jnz ck_xchar ;jmp to ck for XON or XOFF if using protcl ck_rxfull: cmp RX_FREE,0 ;any room left? je rx_overflow store_char: mov bx,RX_IN mov es:[bx],al ;else store the received char inc bx ;advance bufr pointer cmp bx,RX_BTM ;is it time to make the circle? je lp_rxptri store_rxptri: mov RX_IN,bx ;save new RX_IN ptr ifdef DBUG call dsp_RXIN endif dec RX_FREE ;one less byte avlbl in bufr cmp RX_FREE,XOFFCOUNT ;bytes free lower than XOFF level? jb ckifneed_XOFFsnt ret ;done if plenty room in rx buffer ckifneed_XOFFsnt: mov al,STAT2 ;get STAT2 in AL - several cks on it and al,B_XUSE+B_XSENT ;using XON/OFF? / msk unwanted bits in STAT2 jnz send_xoff_ck2 ret ;done if not using XON/OFF prtcl send_xoff_ck2: and al,B_XSENT jz send_xoff1 ;ZR = XOFF not alrdy sent dec XTXRPT ;ck if XOFF has been ignored for 'x' # of chars jz send_xoff2 ;send another XOFF if its been ignored ret ;else back to intrpt loop send_xoff1: or STAT2,B_XSENT ;set bit showing XOFF sent send_xoff2: mov XTXRPT,REPTXOFFVAL ;set up 'ignored' counter mov TXIMMEDCHAR,XOFFCHAR ;XOFF will be next char tx'd and TX_STAT,n B_TXEMPTY ;clr bit that indicates nothing to txmt jz __tx_inton ;strt tx if not alrdy on or other flow hlt actv ret ;back to interrupt loop ;---- Following moved out of main line of rx intrpt routn in attempt to get ; fastest performance in most likely to occur cases. rx_overflow: or STAT1,B_RXOVF ;set bit for rx bufr ovfl if no room ret lp_rxptri: mov bx,RX_TOP jmp s store_rxptri ck_xchar: cmp al,XOFFCHAR je xoff_rcvd ;jmp if char was an XOFF test STAT3,B_XONANY jnz ck_xoffactv ;jmp if any char can be an XON cmp al,XONCHAR ;was it a real XON? jne ck_rxfull ;back to main rxintrpt stream if not XON xon_rcvd: and TX_STAT,n B_XRXD ;clr bit showing XOFF rx'd jz __tx_inton ;rstrt tx if something to tx, no othr flw hlt ret ;back to intrpt loop ck_xoffactv: test TX_STAT,B_XRXD jnz xon_rcvd ;clr XOFF if active and any char can be XON jmp s ck_rxfull ;else treat char as normal char xoff_rcvd: or TX_STAT,B_XRXD ;set bit showing XOFF rx'd (will shut dn tx) ret ;back to intrpt loop rx_intrpt endp ;---- This procedure is called to initiate tx interrupts. Falls ; into the tx interrupt handler. localproc __tx_inton public __tx_inton mov dx,COM_BASE add dx,5 ;xFD)line status register wttxempty: in al,dx and al,00100000b ;test if tx hold reg is empty jz wttxempty ;and wait for it to be empty if its not jmp s $+2 sub dx,4 ;xF9)intrpt enable register in al,dx ;get UART interrupt mask jmp s $+2 or al,00000010b ;set TX intrpts bit out dx,al ;send new mask to the 8250 or TX_STAT,B_TXION ;set bit in TX_STAT that says tx intrpts on dec dx ;xF8) tx hold register __tx_inton endp ;---- Interrupt service routine for transmitter ready condition. This routine ; first checks to see if any flow control has been activated and shuts off ; tx interrupts if it has. Next it looks at the TXIMMEDCHAR and if it is ; not a null transmits it next otherwise transmits the next buffer char. localproc tx_intrpt mov al,FLOW_MASK and al,TX_STAT jnz __shutoff_tx ;shutoff tx'r if XOFF, !CTS, !DSR, or !CD actv xor al,al xchg al,TXIMMEDCHAR or al,al ;ck if TXIMMED was a null & clr it for nxt time jnz txi_char ;jmp if TXIMMED mov ax,TX_SIZE cmp ax,TX_FREE je nomore_tx ;jmp if nothing left to transmit mov bx,TX_OUT ;pointer to next buf char to transmit mov al,es:[bx] ;get tx buffer character inc TX_FREE ;updt tx free bufr space value inc bx cmp bx,TX_BTM jne updt_txptr mov bx,TX_TOP jmp s $+2 updt_txptr: mov TX_OUT,bx ;update the tx buffer pointer ifdef DBUG call dsp_TXOUT endif txi_char: out dx,al ;send the character ifdef LITES call txlites endif ret ;else finished with tx routine nomore_tx: or TX_STAT,B_TXEMPTY ;set bit showing nothing to tx localproc __shutoff_tx public __shutoff_tx inc dx ;xF9) interrupt enable register in al,dx jmp s $+2 and al,00001101b out dx,al ;mask tx interrupt bit off in 8250 and TX_STAT,n B_TXION ;clr bit in TX_STAT that indic tx is on ret ;finished __shutoff_tx endp tx_intrpt endp ifdef DBUG include dbug.inc ;display ring bufr ptr values debug code endif ifdef LITES include lites2.inc ;onscreen rx/tx indicator code endif endseg COMM_TEXT end